home *** CD-ROM | disk | FTP | other *** search
/ Software of the Month Club 2000 October / Software of the Month - Ultimate Collection Shareware 277.iso / pc / PROGRAMS / UTILITY / WINLINUX / DATA1.CAB / programs_-_include / ASM-SPAR.{_A / IO.H < prev    next >
Encoding:
C/C++ Source or Header  |  1999-09-17  |  5.3 KB  |  230 lines
  1. /* $Id: io.h,v 1.19 1998/08/23 05:41:46 ecd Exp $ */
  2. #ifndef __SPARC64_IO_H
  3. #define __SPARC64_IO_H
  4.  
  5. #include <linux/kernel.h>
  6. #include <linux/types.h>
  7.  
  8. #include <asm/page.h>      /* IO address mapping routines need this */
  9. #include <asm/system.h>
  10. #include <asm/asi.h>
  11.  
  12. /* PC crapola... */
  13. #define __SLOW_DOWN_IO    do { } while (0)
  14. #define SLOW_DOWN_IO    do { } while (0)
  15.  
  16.  
  17. #define PCI_DVMA_HASHSZ    256
  18.  
  19. extern unsigned long pci_dvma_offset;
  20. extern unsigned long pci_dvma_mask;
  21.  
  22. extern unsigned long pci_dvma_v2p_hash[PCI_DVMA_HASHSZ];
  23. extern unsigned long pci_dvma_p2v_hash[PCI_DVMA_HASHSZ];
  24.  
  25. #define pci_dvma_ahashfn(addr)    (((addr) >> 24) & 0xff)
  26.  
  27. extern __inline__ unsigned long virt_to_phys(volatile void *addr)
  28. {
  29.     unsigned long vaddr = (unsigned long)addr;
  30.     unsigned long off;
  31.  
  32.     /* Handle kernel variable pointers... */
  33.     if (vaddr < PAGE_OFFSET)
  34.         vaddr += PAGE_OFFSET - (unsigned long)&empty_zero_page;
  35.  
  36.     off = pci_dvma_v2p_hash[pci_dvma_ahashfn(vaddr - PAGE_OFFSET)];
  37.     return vaddr + off;
  38. }
  39.  
  40. extern __inline__ void *phys_to_virt(unsigned long addr)
  41. {
  42.     unsigned long paddr = addr & 0xffffffffUL;
  43.     unsigned long off;
  44.  
  45.     off = pci_dvma_p2v_hash[pci_dvma_ahashfn(paddr)];
  46.     return (void *)(paddr + off);
  47. }
  48.  
  49. #define virt_to_bus virt_to_phys
  50. #define bus_to_virt phys_to_virt
  51.  
  52. extern __inline__ unsigned long bus_dvma_to_mem(unsigned long vaddr)
  53. {
  54.     return vaddr & pci_dvma_mask;
  55. }
  56.  
  57.  
  58. extern __inline__ unsigned int inb(unsigned long addr)
  59. {
  60.     unsigned int ret;
  61.  
  62.     __asm__ __volatile__("lduba [%1] %2, %0"
  63.                  : "=r" (ret)
  64.                  : "r" (addr), "i" (ASI_PL));
  65.  
  66.     return ret;
  67. }
  68.  
  69. extern __inline__ unsigned int inw(unsigned long addr)
  70. {
  71.     unsigned int ret;
  72.  
  73.     __asm__ __volatile__("lduha [%1] %2, %0"
  74.                  : "=r" (ret)
  75.                  : "r" (addr), "i" (ASI_PL));
  76.  
  77.     return ret;
  78. }
  79.  
  80. extern __inline__ unsigned int inl(unsigned long addr)
  81. {
  82.     unsigned int ret;
  83.  
  84.     __asm__ __volatile__("lduwa [%1] %2, %0"
  85.                  : "=r" (ret)
  86.                  : "r" (addr), "i" (ASI_PL));
  87.  
  88.     return ret;
  89. }
  90.  
  91. extern __inline__ void outb(unsigned char b, unsigned long addr)
  92. {
  93.     __asm__ __volatile__("stba %0, [%1] %2"
  94.                  : /* no outputs */
  95.                  : "r" (b), "r" (addr), "i" (ASI_PL));
  96. }
  97.  
  98. extern __inline__ void outw(unsigned short w, unsigned long addr)
  99. {
  100.     __asm__ __volatile__("stha %0, [%1] %2"
  101.                  : /* no outputs */
  102.                  : "r" (w), "r" (addr), "i" (ASI_PL));
  103. }
  104.  
  105. extern __inline__ void outl(unsigned int l, unsigned long addr)
  106. {
  107.     __asm__ __volatile__("stwa %0, [%1] %2"
  108.                  : /* no outputs */
  109.                  : "r" (l), "r" (addr), "i" (ASI_PL));
  110. }
  111.  
  112. #define inb_p inb
  113. #define outb_p outb
  114.  
  115. extern void outsb(unsigned long addr, const void *src, unsigned long count);
  116. extern void outsw(unsigned long addr, const void *src, unsigned long count);
  117. extern void outsl(unsigned long addr, const void *src, unsigned long count);
  118. extern void insb(unsigned long addr, void *dst, unsigned long count);
  119. extern void insw(unsigned long addr, void *dst, unsigned long count);
  120. extern void insl(unsigned long addr, void *dst, unsigned long count);
  121.  
  122. /* Memory functions, same as I/O accesses on Ultra. */
  123. #define readb(addr)        inb((unsigned long)(addr))
  124. #define readw(addr)        inw((unsigned long)(addr))
  125. #define readl(addr)        inl((unsigned long)(addr))
  126. #define writeb(b, addr)        outb((b), (unsigned long)(addr))
  127. #define writew(w, addr)        outw((w), (unsigned long)(addr))
  128. #define writel(l, addr)        outl((l), (unsigned long)(addr))
  129.  
  130. /*
  131.  * Memcpy to/from I/O space is just a regular memory operation on
  132.  * Ultra as well.
  133.  */
  134.  
  135. /*
  136.  * FIXME: Write faster routines using ASL_*L for this.
  137.  */
  138. static inline void *
  139. memset_io(void *dst, int c, __kernel_size_t n)
  140. {
  141.     char *d = dst;
  142.  
  143.     while (n--)
  144.         *d++ = c;
  145.  
  146.     return dst;
  147. }
  148.  
  149. static inline void *
  150. memcpy_fromio(void *dst, const void *src, __kernel_size_t n)
  151. {
  152.     const char *s = src;
  153.     char *d = dst;
  154.  
  155.     while (n--)
  156.         *d++ = *s++;
  157.  
  158.     return dst;
  159. }
  160.  
  161. static inline void *
  162. memcpy_toio(void *dst, const void *src, __kernel_size_t n)
  163. {
  164.     const char *s = src;
  165.     char *d = dst;
  166.  
  167.     while (n--)
  168.         *d++ = *s++;
  169.  
  170.     return dst;
  171. }
  172.  
  173. #if 0 /* XXX Not exactly, we need to use ASI_*L from/to the I/O end,
  174.        * XXX so these are disabled until we code that stuff.
  175.        */
  176. #define eth_io_copy_and_sum(a,b,c,d) eth_copy_and_sum((a),((char *)(b)),(c),(d))
  177. #endif
  178.  
  179. static inline int check_signature(unsigned long io_addr,
  180.                   const unsigned char *signature,
  181.                   int length)
  182. {
  183.     int retval = 0;
  184.     do {
  185.         if (readb(io_addr++) != *signature++)
  186.             goto out;
  187.     } while (--length);
  188.     retval = 1;
  189. out:
  190.     return retval;
  191. }
  192.  
  193. /*
  194.  * On the sparc we have the whole physical IO address space mapped at all
  195.  * times, so ioremap() and iounmap() do not need to do anything.
  196.  */
  197. extern __inline__ void *ioremap(unsigned long offset, unsigned long size)
  198. {
  199.     return __va(offset);
  200. }
  201.  
  202. extern __inline__ void iounmap(void *addr)
  203. {
  204. }
  205.  
  206.  
  207. extern void sparc_ultra_mapioaddr(unsigned long physaddr,
  208.                   unsigned long virt_addr,
  209.                   int bus, int rdonly);
  210. extern void sparc_ultra_unmapioaddr(unsigned long virt_addr);
  211.  
  212. extern __inline__ void mapioaddr(unsigned long physaddr,
  213.                  unsigned long virt_addr,
  214.                  int bus, int rdonly)
  215. {
  216.     sparc_ultra_mapioaddr(physaddr, virt_addr, bus, rdonly);
  217. }
  218.  
  219. extern __inline__ void unmapioaddr(unsigned long virt_addr)
  220. {
  221.     sparc_ultra_unmapioaddr(virt_addr);
  222. }
  223.  
  224. extern void *sparc_alloc_io(u32 pa, void *va, int sz, char *name,
  225.                 u32 io, int rdonly);
  226. extern void sparc_free_io (void *va, int sz);
  227. extern void *sparc_dvma_malloc (int sz, char *name, __u32 *dvma_addr);
  228.  
  229. #endif /* !(__SPARC64_IO_H) */
  230.